#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <sys/signalfd.h>

#include "constantes.h"
#include "log.h"
#include "ComPerifericos.h"
#include "colas.h"
#include "structs_commons.h"

#include "TratamientoPlanif.h"

//EN ESTE HILO SE VA A TRATAR LA COMUNICACION DEL PPD CON EL PFS

nodoCola *DevolverNodo(nodoCola **cola){

	nodoCola *nodo;

	nodo = *cola;

	*cola = (*cola)->sgte;

	return nodo;
}

void EnviarPedidoLectura(stNIPC pedido){

	int sector;

	//pedido.iPayloadDescriptor = 0xR;//PRAID
	pedido.iType = 1;//lectura
	memset(pedido.sDescriptorOriginal, 0, 16);
	pedido.sPayload_lenth = sizeof(int);

	//stNIPC_serializer(&pedido, );
	//stPLecturaSector_serializer(&sector);

	//send(cantidad de bytes de los dos serializer)
}


void TratamientoPlanif(void *arg){

	argThread *argHilo;
	argHilo = (argThread*)malloc(sizeof(argThread));
	argHilo = arg;

	/////////////////////////////////////////////////
	/////VER DONDE HACER EL FREE DE argHilo!!!!!!!!!!
	/////////////////////////////////////////////////

	t_log *log = argHilo->log;
	int signal = argHilo->signalFd;

	//int signal = 4;
	int socket, maxfd;
	int escritos = 0;
	int recibidos = 0;
	nodoCola *colaPedidos, *nodo;
	fd_set read_fds;
	fd_set master2;
	struct signalfd_siginfo info;
	ssize_t s;
	stNIPC st;
	char *cadena;
	stNIPC *cabecera;
	t_stream *stream;


	socket = glob_listaDiscos->data.sockPPD;
	colaPedidos = glob_listaDiscos->data.iniCola;



	//char bufSect[512];

	FD_ZERO(&read_fds);
	FD_ZERO(&master2);
	FD_SET(signal, &master2);
	FD_SET(socket, &master2);

	maxfd = (signal > socket)? signal: socket;

	while(1){
		read_fds = master2;
		if(select(maxfd + 1, &read_fds, NULL, NULL, NULL) == -1){
			log_error(log, SNOMBREPROCESO, "Message error: %s", "Error en el SELECT HILO PPD");
			return;
		}

		if(FD_ISSET(signal, &read_fds)){
			//HAY UN PEDIDO QUE ATENDER DE LA COLA!!!

			//PRIMERO APAGO LA SEÑAL PARA QUE NO SIGA LLAMANDO
            s = read(signal, &info, sizeof(struct signalfd_siginfo));
            if (s != sizeof(struct signalfd_siginfo))
                log_error(log, SNOMBREPROCESO, "Message error: %s", "Error en el read signalfd");

            //VACIO LA COLA DE PEDIDOS
			while(colaPedidos!= NULL){
				nodo = DevolverNodo(&colaPedidos);

				switch(nodo->tipoPedido){
				case RSincro:
					EnviarPedidoLectura(st);
					//stNIPC_serializer(&st, )
					break;
				case WSincro:
					escritos = escritos + 1;
					break;
				case R:
					break;
				case W:
					break;
				}
			}
			if(glob_listaDiscos->data.sincronizado == 0 && (escritos == sectoresDisco)){
				//el disco esta sincronizado => sincro = 1
			    glob_listaDiscos->data.sincronizado = 1;
			}

		}

		if(FD_ISSET(socket, &read_fds)){
			//HAY ACTIVIDAD CON EL PPD(Me respondio algo, algun sector que le pedi)
			cadena = (char*)malloc(sizeof(stNIPC));
			if((recibidos = recv(socket, cadena, sizeof(stNIPC), MSG_WAITALL)) <= 0){
				if(recibidos == 0){
				//conexion cerrada
					log_error(log, SNOMBREPROCESO, "Message error: %s", "PPD desconectado");
					close(socket);
					FD_CLR(socket, &master2);
					RestarPlanificador();//hacerla global????
					//recorrer la lista y reacomodar los pedidos si los tiene
					ReacomodarPedidos();
				}
				else{
					perror("recv");
					log_error(log, SNOMBREPROCESO, "Message error: %s", "Error al recibir los datos");
				}


			}
			else{
				//recibi respuesta del ppd, analizar y mandar al pfs
				stream = (t_stream*)malloc(sizeof(t_stream));
				stream->data = cadena;
				stream->length = sizeof(stNIPC);

				cabecera = (stNIPC*)malloc(sizeof(stNIPC));

				stNIPC_deserializer(stream, cabecera);





			}
		}

	}//fin while(1)
}






